// pages/ticketAdd/ticketAdd.js
const api = require("../../config/api.js");
const util = require("../../utils/util.js");
const shareCard = require("../../utils/shareCard.js");

Page({
  /**
   * 页面的初始数据
   */
  data: {
    // 表单数据
    tradeType: 0, // 0:求购 1:转卖
    ticketType: 0, // 0:1日 1:1.5日 2:2日 3:多日
    skiResortIndex: 0,
    skiResortList: [],
    // SkiDropdown组件相关
    skiDropdownOpen: false,
    skiDropdownTop: 0,
    selectedSkiId: null, // 当前选中的雪场ID，用于回显和传递给组件
    selectedSkiName: "", // 当前选中的雪场名称，用于显示
    selectedDate: "",
    timeSlot: 0, // 0:全天 1:上午 2:下午 3:夜场
    quantity: 0,
    deliveryType: 0, // 0:面交 1:线上
    isFull: 0, // 0:残票 1:整票
    ticketPrice: "",
    description: "",
    wechatContact: "",
    phoneContact: "",

    // 选项列表
    ticketTypeList: [
      { text: "1日", value: 0 },
      { text: "1.5日", value: 1 },
      { text: "2日", value: 2 },
      { text: "多日", value: 3 }
    ],
    timeSlotList: [
      { text: "全天", value: 0 },
      { text: "上午", value: 1 },
      { text: "下午", value: 2 },
      { text: "夜场", value: 3 }
    ],
    deliveryList: [
      { text: "面交", value: 0 },
      { text: "线上", value: 1 }
    ],

    // 表单验证
    canSubmit: false,

    // 加载状态
    loading: false,

    // 成功弹窗相关
    showSuccessPopup: false,

    // 编辑模式相关
    editId: null,
    isEditMode: false,
    // 提交按钮文案
    submitButtonText: "提交",
    // 发布成功后返回的ID
    publishedId: null,
    // 分享卡片图片路径
    shareCardImageUrl: null,

    // 是否已加入俱乐部
    isClubMember: false,

    // 日期选择器相关
    showDatePicker: false,
    currentDate: new Date().getTime(),
    minDate: new Date().getTime(),
    maxDate: new Date(
      new Date().getTime() + 365 * 24 * 60 * 60 * 1000
    ).getTime() // 一年后
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    console.log("雪票发布页面加载完成", options);

    // 从URL参数获取初始值
    if (options.type !== undefined) {
      this.setData({
        tradeType: parseInt(options.type)
      });
    }
    if (options.ticket !== undefined) {
      this.setData({
        isFull: parseInt(options.ticket)
      });
    }

    // 处理编辑模式 - 如果有id参数，则获取详情数据回显
    if (options.id) {
      this.setData({
        editId: options.id,
        isEditMode: true,
        submitButtonText: "更新"
      });
      // 设置页面标题为"编辑雪票"
      wx.setNavigationBarTitle({
        title: "编辑雪票"
      });
      this.loadTicketDetail(options.id);
    }
    // 处理再发一单模式 - 如果有copyId参数，则加载数据并回填（但不设置编辑模式）
    else if (options.copyId) {
      // 设置页面标题为"发布雪票"
      wx.setNavigationBarTitle({
        title: "发布雪票"
      });
      // 加载数据并回填，但不设置编辑模式
      this.loadTicketDetailForCopy(options.copyId);
    } else {
      // 设置页面标题为"发布雪票"
      wx.setNavigationBarTitle({
        title: "发布雪票"
      });
    }

    // 不再需要加载雪场列表，SkiDropdown组件内部会处理数据加载

    // 设置默认日期为今天
    this.setDefaultDate();

    // 验证表单
    this.validateForm();
  },

  /**
   * 返回按钮
   */
  onBack: function () {
    wx.navigateBack();
  },

  /**
   * 加载雪票详情数据
   */
  loadTicketDetail: function (id) {
    wx.showLoading({
      title: "加载中...",
      mask: true
    });

    util
      .request(
        api.TicketInfo,
        {
          id: id
        },
        "POST",
        "application/json"
      )
      .then((res) => {
        console.log("雪票详情响应:", res);

        const normalizedRes = util.normalizeApiResponse(res);

        if (normalizedRes.success && normalizedRes.data) {
          const detailData = normalizedRes.data;

          console.log("雪票详情加载成功，数据已回显");

          // 处理日期字段：如果返回的是时间戳，转换为日期字符串
          const formattedDate = detailData.date ? this.formatDate(detailData.date) : "";
          
          // 处理日期选择器的当前日期（需要时间戳格式）
          let dateTimeStamp = new Date().getTime();
          if (detailData.date) {
            try {
              // 如果date是时间戳（数字或字符串）
              let ts = typeof detailData.date === 'string' ? parseInt(detailData.date) : detailData.date;
              // 如果时间戳是秒级（10位），转换为毫秒级（13位）
              ts = ts < 10000000000 ? ts * 1000 : ts;
              const date = new Date(ts);
              if (!isNaN(date.getTime())) {
                dateTimeStamp = date.getTime();
              }
            } catch (error) {
              console.log("解析日期失败:", error);
            }
          }

          // 回显数据到表单
          this.setData({
            tradeType: detailData.type || 0,
            ticketType: detailData.ticketType || 0,
            selectedDate: formattedDate, // 使用格式化后的日期字符串
            timeSlot: detailData.ticket || 0,
            quantity: detailData.count || 0,
            deliveryType: detailData.getType || 0,
            ticketPrice: detailData.price ? detailData.price.toString() : "",
            description: detailData.detail || "",
            wechatContact: detailData.wechat || "",
            phoneContact: detailData.phone ? String(detailData.phone) : "",
            isFull: detailData.isFull || 0,
            currentDate: dateTimeStamp // 设置日期选择器的当前日期（时间戳格式）
          });

          // 使用addressId字段（雪场ID），设置selectedSkiId用于回显
          // SkiDropdown组件会根据selectedSkiId自动回显，不需要维护skiResortList
          const skiId = detailData.addressId || null;
          const skiName = detailData.skiAddress || "";
          if (skiId) {
            this.setData({
              selectedSkiId: skiId,
              selectedSkiName: skiName
            });
            console.log("设置雪场ID用于回显:", skiId, "雪场名称:", skiName);
          } else {
            // 如果没有雪场ID，清空selectedSkiId
            this.setData({
              selectedSkiId: null,
              selectedSkiName: ""
            });
          }
          // 验证表单
          this.validateForm();
        } else {
          wx.showToast({
            title: normalizedRes.message || "加载详情失败",
            icon: "none"
          });
        }
      })
      .catch((err) => {
        console.error("加载雪票详情失败:", err);
        wx.showToast({
          title: "网络错误，请重试",
          icon: "none"
        });
      })
      .finally(() => {
        wx.hideLoading();
      });
  },

  /**
   * 将时间戳转换为 yyyy-mm-dd 格式
   */
  formatDate: function(timestamp) {
    if (!timestamp) return '';
    
    // 如果已经是字符串格式（yyyy-mm-dd），直接返回
    if (typeof timestamp === 'string' && timestamp.includes('-')) {
      return timestamp;
    }
    
    // 如果时间戳是字符串，转换为数字
    const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp;
    
    // 如果时间戳是秒级（10位），转换为毫秒级（13位）
    const timestampMs = ts < 10000000000 ? ts * 1000 : ts;
    
    const date = new Date(timestampMs);
    
    // 验证日期是否有效
    if (isNaN(date.getTime())) {
      console.warn("无效的时间戳:", timestamp);
      return '';
    }
    
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    
    return `${year}-${month}-${day}`;
  },

  /**
   * 加载雪票详情数据用于再发一单（回填部分数据）
   */
  loadTicketDetailForCopy: function (id) {
    wx.showLoading({
      title: "加载中...",
      mask: true
    });

    util
      .request(
        api.TicketInfo,
        {
          id: id
        },
        "POST",
        "application/json"
      )
      .then((res) => {
        console.log("雪票详情响应（再发一单）:", res);

        const normalizedRes = util.normalizeApiResponse(res);

        if (normalizedRes.success && normalizedRes.data) {
          const detailData = normalizedRes.data;

          // 再发一单模式：回填所有表单字段，仅不回填使用时间
          // 回填的表单字段：交易类型、票类型、数量、交付方式、雪场、日期、价格、详情、微信号、手机号
          // 不回填的字段：使用时间(timeSlot) - 让用户重新选择
          // 使用addressId作为雪场ID字段，skiAddress作为雪场名称字段
          const skiId = detailData.addressId || null;
          const skiName = detailData.skiAddress || "";

          // 回填所有表单字段（除了使用时间）
          this.setData({
            // 表单字段
            tradeType: detailData.type || 0,
            ticketType: detailData.ticketType || 0,
            quantity: detailData.count || 0,
            deliveryType: detailData.getType || 0,
            // 表单字段：价格、详情、联系方式
            ticketPrice: detailData.price || "",
            description: detailData.detail || "",
            wechatContact: detailData.wechat || "",
            phoneContact: detailData.phone || "",
            // UI状态字段（用于组件回显，不是表单字段）
            selectedSkiId: skiId,
            selectedSkiName: skiName
          });

          // 注意：日期和使用时间(timeSlot)不回填，让用户重新选择

          console.log(
            "再发一单：设置雪场ID用于回显:",
            skiId,
            "雪场名称:",
            skiName
          );

          // SkiDropdown组件会根据selectedSkiId自动回显，不需要维护skiResortList和索引
          // 已在上面的setData中设置了selectedSkiId

          console.log("再发一单：数据回填完成");

          // 验证表单
          this.validateForm();
        } else {
          wx.showToast({
            title: normalizedRes.message || "加载详情失败",
            icon: "none"
          });
        }
      })
      .catch((err) => {
        console.error("加载雪票详情失败（再发一单）:", err);
        wx.showToast({
          title: "网络错误，请重试",
          icon: "none"
        });
      })
      .finally(() => {
        wx.hideLoading();
      });
  },

  /**
   * 设置默认日期
   */
  setDefaultDate: function () {
    const today = new Date();
    const year = today.getFullYear();
    const month = String(today.getMonth() + 1).padStart(2, "0");
    const day = String(today.getDate()).padStart(2, "0");
    const defaultDate = `${year}-${month}-${day}`;

    this.setData({
      selectedDate: defaultDate
    });
  },

  /**
   * 雪场选择 - 使用SkiDropdown组件
   */
  onSkiResortClick: function () {
    // 直接使用data中的selectedSkiId（已在加载详情时设置，或由用户选择后设置）
    const selectedSkiId = this.data.selectedSkiId || null;

    // 获取系统信息，计算从底部出现的位置
    const systemInfo = wx.getSystemInfoSync();
    const panelHeight = 320; // SkiDropdown组件高度
    const top = systemInfo.windowHeight - panelHeight;

    this.setData({
      skiDropdownOpen: true,
      skiDropdownTop: top,
      selectedSkiId: selectedSkiId
    });
  },

  /**
   * 关闭雪场选择器
   */
  closeSkiDropdown: function () {
    this.setData({
      skiDropdownOpen: false
    });
  },

  /**
   * SkiDropdown组件change事件处理（单选模式）
   */
  onSkiDropdownChange: function (e) {
    const optionId = e.detail.value;
    const optionName = e.detail.name;

    // 处理"不限"选项：optionId为null时重置（虽然showAllOption=false，但保留此逻辑以防万一）
    if (optionId === null || optionId === undefined || optionId === "") {
      this.setData({
        selectedSkiId: null,
        selectedSkiName: ""
      });
      console.log("清空选择的雪场");
      this.validateForm();
      return;
    }

    if (!optionId) {
      console.warn("选择雪场时缺少ID");
      return;
    }

    // 更新selectedSkiId和selectedSkiName，SkiDropdown组件会自动回显
    // 不需要维护skiResortList和skiResortIndex，因为已经改用SkiDropdown组件
    this.setData({
      selectedSkiId: optionId,
      selectedSkiName: optionName || ""
    });

    console.log("选择的雪场:", {
      name: optionName,
      id: optionId
    });
    this.validateForm();
  },

  /**
   * 票类型选择
   */
  onTicketTypeChange: function (e) {
    const value = parseInt(e.currentTarget.dataset.value);
    this.setData({
      ticketType: value
    });
    this.validateForm();
  },

  /**
   * 显示日期选择器
   */
  onDateClick: function () {
    // 如果已经有选择的日期，使用已选择的日期；否则使用当前日期
    let currentDate = new Date().getTime();

    if (this.data.selectedDate) {
      try {
        // 确保日期格式正确
        const dateStr = this.data.selectedDate;
        const date = new Date(dateStr);
        if (!isNaN(date.getTime())) {
          currentDate = date.getTime();
        }
      } catch (error) {
        console.log("解析已选择日期失败，使用当前日期:", error);
      }
    }

    console.log("显示日期选择器，当前日期:", new Date(currentDate));

    this.setData({
      showDatePicker: true,
      currentDate: currentDate
    });
  },

  /**
   * 日期选择器相关方法
   */
  onDateConfirm: function (e) {
    console.log("日期选择器confirm事件:", e.detail);

    // van-calendar 单选模式下直接返回日期时间戳
    const date = new Date(e.detail);
    const dateStr = `${date.getFullYear()}-${String(
      date.getMonth() + 1
    ).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;

    this.setData({
      selectedDate: dateStr,
      currentDate: e.detail,
      showDatePicker: false
    });

    console.log("选择的日期:", dateStr);
    this.validateForm();
  },

  onDatePickerClose: function () {
    console.log("关闭日期选择器");
    this.setData({
      showDatePicker: false
    });
  },

  /**
   * 时段选择
   */
  onTimeSlotChange: function (e) {
    const value = parseInt(e.currentTarget.dataset.value);
    this.setData({
      timeSlot: value
    });
    this.validateForm();
  },

  /**
   * 增加数量
   */
  increaseQuantity: function () {
    this.setData({
      quantity: this.data.quantity + 1
    });
    this.validateForm();
  },

  /**
   * 减少数量
   */
  decreaseQuantity: function () {
    if (this.data.quantity > 0) {
      this.setData({
        quantity: this.data.quantity - 1
      });
      this.validateForm();
    }
  },

  /**
   * 交付方式选择
   */
  onDeliveryChange: function (e) {
    const value = parseInt(e.currentTarget.dataset.value);
    this.setData({
      deliveryType: value
    });
    this.validateForm();
  },

  /**
   * 价格输入
   */
  onPriceInput: function (e) {
    let value = e.detail.value;

    // 只允许数字和小数点
    value = value.replace(/[^\d.]/g, "");

    // 确保只有一个小数点
    const parts = value.split(".");
    if (parts.length > 2) {
      value = parts[0] + "." + parts.slice(1).join("");
    }

    // 限制最大值为99999
    const numValue = parseFloat(value);
    if (!isNaN(numValue) && numValue > 99999) {
      value = "99999";
      wx.showToast({
        title: "雪票价格不能超过99999",
        icon: "none",
        duration: 2000
      });
    }

    this.setData({
      ticketPrice: value
    });
    this.validateForm();
  },

  /**
   * 描述输入
   */
  onDescriptionInput: function (e) {
    this.setData({
      description: e.detail.value
    });
    this.validateForm();
  },

  /**
   * 微信输入
   */
  onWechatInput: function (e) {
    let value = e.detail.value;
    // 仅不能输入汉字，其他字符都可以输入（字母、数字、特殊符号等）
    // 过滤掉汉字（Unicode范围：\u4e00-\u9fa5）
    value = value.replace(/[\u4e00-\u9fa5]/g, "");
    // 限制最大长度为20个字符
    if (value.length > 20) {
      value = value.substring(0, 20);
      wx.showToast({
        title: "微信号最多20个字符",
        icon: "none",
        duration: 1500
      });
    }
    this.setData({
      wechatContact: value
    });
    this.validateForm();
  },

  /**
   * 电话输入
   */
  onPhoneInput: function (e) {
    let value = e.detail.value;
    // 只允许数字，过滤掉所有非数字字符（包括中文）
    value = value.replace(/[^\d]/g, "");
    // 限制最大长度为11位
    if (value.length > 11) {
      value = value.substring(0, 11);
      wx.showToast({
        title: "手机号只能输入11位",
        icon: "none",
        duration: 1500
      });
    }
    this.setData({
      phoneContact: value
    });
    this.validateForm();
  },

  /**
   * 表单验证
   */
  validateForm: function () {
    const {
      selectedSkiId,
      selectedDate,
      quantity,
      ticketPrice,
      wechatContact
    } = this.data;

    // 使用selectedSkiId验证雪场是否已选择，不再依赖skiResortList
    const canSubmit =
      selectedSkiId !== null &&
      selectedSkiId !== undefined &&
      selectedSkiId !== "" &&
      selectedDate &&
      quantity > 0 &&
      ticketPrice &&
      wechatContact;

    this.setData({
      canSubmit: canSubmit
    });
  },

  /**
   * 提交表单
   */
  onSubmit: function () {
    // 单独验证雪场是否已选择
    if (
      !this.data.selectedSkiId ||
      this.data.selectedSkiId === null ||
      this.data.selectedSkiId === ""
    ) {
      wx.showToast({
        title: "请选择雪场",
        icon: "none",
        duration: 2000
      });
      return;
    }

    if (!this.data.canSubmit) {
      wx.showToast({
        title: "请完善必填信息",
        icon: "none",
        duration: 2000
      });
      return;
    }

    // 如果填写了电话，必须至少11位
    if (
      this.data.phoneContact &&
      this.data.phoneContact.length > 0 &&
      this.data.phoneContact.length < 11
    ) {
      wx.showToast({
        title: "手机号不能少于11位",
        icon: "none"
      });
      return;
    }

    // 在提交前进行登录校验
    const that = this
    
    // 点击提交时缓存表单数据（无论是否登录）
    this.cacheFormData()
    
    util.executeWithLoginCheck(
      () => {
        // 用户已登录，执行提交
        if (that.data.isEditMode) {
          that.updateTicket();
        } else {
          that.submitTicket();
        }
      },
      "发布雪票需要先登录，是否立即登录？",
      "/pages/ticketAdd/ticketAdd"
    );
  },

  /**
   * 缓存表单数据
   */
  cacheFormData: function() {
    const cacheKey = 'ticketAdd_formData_cache'
    // 缓存所有表单相关数据
    const cacheData = {
      tradeType: this.data.tradeType,
      ticketType: this.data.ticketType,
      selectedSkiId: this.data.selectedSkiId,
      selectedSkiName: this.data.selectedSkiName,
      selectedDate: this.data.selectedDate,
      timeSlot: this.data.timeSlot,
      quantity: this.data.quantity,
      deliveryType: this.data.deliveryType,
      isFull: this.data.isFull,
      ticketPrice: this.data.ticketPrice,
      description: this.data.description,
      wechatContact: this.data.wechatContact,
      phoneContact: this.data.phoneContact,
      currentDate: this.data.currentDate
    }
    wx.setStorageSync(cacheKey, cacheData)
    console.log('已缓存雪票表单数据:', cacheData)
  },

  /**
   * 恢复缓存的表单数据
   */
  restoreFormData: function() {
    const cacheKey = 'ticketAdd_formData_cache'
    const cachedData = wx.getStorageSync(cacheKey)
    
    if (cachedData) {
      console.log('恢复缓存的雪票表单数据:', cachedData)
      this.setData({
        tradeType: cachedData.tradeType,
        ticketType: cachedData.ticketType,
        selectedSkiId: cachedData.selectedSkiId,
        selectedSkiName: cachedData.selectedSkiName,
        selectedDate: cachedData.selectedDate,
        timeSlot: cachedData.timeSlot,
        quantity: cachedData.quantity,
        deliveryType: cachedData.deliveryType,
        isFull: cachedData.isFull,
        ticketPrice: cachedData.ticketPrice,
        description: cachedData.description,
        wechatContact: cachedData.wechatContact,
        phoneContact: cachedData.phoneContact,
        currentDate: cachedData.currentDate
      })
      // 恢复后清除缓存
      wx.removeStorageSync(cacheKey)
      // 验证表单
      this.validateForm()
    }
  },

  /**
   * 更新雪票信息
   */
  updateTicket: function () {
    const that = this;
    const {
      tradeType,
      ticketType,
      skiResortList,
      skiResortIndex,
      selectedDate,
      timeSlot,
      quantity,
      deliveryType,
      ticketPrice,
      description,
      wechatContact,
      phoneContact
    } = this.data;

    // 构建更新数据 - 注意接口参数名
    // 使用selectedSkiId作为雪场ID
    const updateData = {
      id: this.data.editId,
      type: tradeType, // 0:求购 1:转让
      ticketType: ticketType, // 0:1日 1:1.5日 2:2日 3:多日
      addressId: this.data.selectedSkiId, // 使用addressId作为雪场ID字段
      skiAddress: this.data.selectedSkiName || "", // 雪场名称
      count: quantity, // 数量
      date: selectedDate, // 日期
      detail: description, // 详情
      getType: deliveryType, // 取票方式 0:面交 1:线上
      phone: phoneContact || "", // 注意：接口要求phone是string类型
      price: parseFloat(ticketPrice), // 价格
      ticket: timeSlot, // 0:全天 1:上午 2:下午 3:夜场
      wechat: wechatContact || ""
    };

    console.log("调用编辑雪票接口，参数:", updateData);
    console.log("接口地址:", api.TicketEdit);

    that.setData({
      loading: true
    });

    // 调用雪票编辑API
    util
      .request(api.TicketEdit, updateData, "POST", "application/json")
      .then(function (res) {
        console.log("雪票编辑响应:", res);

        const normalizedRes = util.normalizeApiResponse(res);
        console.log("标准化后的响应:", normalizedRes);

        if (normalizedRes.success) {
          // 更新成功后清除缓存数据
          const cacheKey = 'ticketAdd_formData_cache'
          wx.removeStorageSync(cacheKey)
          console.log('更新成功，已清除缓存的表单数据')
          
          wx.showToast({
            title: "更新成功",
            icon: "success"
          });
          setTimeout(() => {
            wx.navigateBack();
          }, 1500);
        } else {
          wx.showToast({
            title: normalizedRes.message || "更新失败",
            icon: "none",
            duration: 2000
          });
        }
      })
      .catch(function (err) {
        console.error("雪票编辑请求失败:", err);
        wx.showToast({
          title: "网络错误，请重试",
          icon: "none"
        });
      })
      .finally(function () {
        that.setData({
          loading: false
        });
      });
  },

  /**
   * 提交雪票信息
   */
  submitTicket: function () {
    const that = this;
    const {
      tradeType,
      ticketType,
      skiResortList,
      skiResortIndex,
      selectedDate,
      timeSlot,
      quantity,
      deliveryType,
      ticketPrice,
      description,
      wechatContact,
      phoneContact,
      isFull
    } = this.data;

    // 构建提交数据
    // 使用selectedSkiId作为雪场ID
    const submitData = {
      type: tradeType,
      ticketType: ticketType,
      addressId: this.data.selectedSkiId, // 使用addressId作为雪场ID字段
      skiAddress: this.data.selectedSkiName || "", // 雪场名称
      date: selectedDate,
      ticket: timeSlot,
      count: quantity,
      isFull: isFull,
      price: parseFloat(ticketPrice),
      getType: deliveryType,
      detail: description,
      wechat: wechatContact,
      phone: phoneContact
    };

    console.log("提交雪票数据:", submitData);

    that.setData({
      loading: true
    });

    // 调用真实的雪票发布API
    util
      .request(api.TicketAdd, submitData, "POST", "application/json")
      .then(function (res) {
        console.log("雪票发布响应:", res);

        // 使用标准化的响应处理
        const normalizedRes = util.normalizeApiResponse(res);
        console.log("标准化后的响应:", normalizedRes);

        if (normalizedRes.success) {
          // 提交成功后清除缓存数据
          const cacheKey = 'ticketAdd_formData_cache'
          wx.removeStorageSync(cacheKey)
          console.log('提交成功，已清除缓存的表单数据')
          
          const publishedId = normalizedRes.data?.id || normalizedRes.data || null;
          // 显示成功弹窗，保存返回的ID
          that.setData({
            showSuccessPopup: true,
            publishedId: publishedId
          });
        } else {
          wx.showToast({
            title: normalizedRes.message || "发布失败",
            icon: "none"
          });
        }
      })
      .catch(function (err) {
        console.error("雪票发布请求失败:", err);
        wx.showToast({
          title: "网络错误，请重试",
          icon: "none"
        });
      })
      .finally(function () {
        that.setData({
          loading: false
        });
      });
  },

  /**
   * 关闭成功弹窗
   */
  closeSuccessPopup: function () {
    this.setData({
      showSuccessPopup: false
    });
    // 返回上一层页面
    setTimeout(() => {
      wx.navigateBack();
    }, 300);
  },

  /**
   * 阻止事件冒泡
   */
  stopPropagation: function () {
    // 阻止事件冒泡，防止点击弹窗内容时关闭弹窗
  },

  /**
   * 生成分享卡片（预生成并缓存）
   */
  generateShareCard: function(publishedId) {
    const that = this;
    
    if (!publishedId) {
      return Promise.resolve();
    }
    
    // 获取详情数据
    return util.request(api.TicketInfo, { id: publishedId }, 'POST', 'application/json').then((res) => {
      const normalizedRes = util.normalizeApiResponse(res);
      
      if (normalizedRes.success && normalizedRes.data) {
        const ticketData = normalizedRes.data;
        
        // 将API返回的数据转换为与详情页一致的格式，确保分享卡片内容一致
        const ticketDetail = {
          id: publishedId,
          type: ticketData.type, // 0:求购 1:转让
          ticketType: ticketData.ticketType, // 0:1日 1:1.5日 2:2日 3:多日
          isFull: ticketData.isFull, // 0:残票 1:整票
          skiResort: {
            id: ticketData.addressId || 1,
            name: ticketData.skiAddress || ""
          },
          date: that.formatDate(ticketData.date),
          timeSlot: ticketData.ticket, // 0:全天 1:上午 2:下午 3:夜场
          quantity: ticketData.count || 1,
          price: ticketData.price || 0,
          description: ticketData.detail || ""
        };
        
        // 异步生成分享卡片，使用与详情页相同的数据结构
        return shareCard.getShareCard('ticket', {
          id: publishedId,
          type: ticketDetail.type,
          skiResort: ticketDetail.skiResort,
          date: ticketDetail.date,
          timeSlot: ticketDetail.timeSlot,
          ticketType: ticketDetail.ticketType,
          isFull: ticketDetail.isFull,
          quantity: ticketDetail.quantity,
          price: ticketDetail.price,
          description: ticketDetail.description
        }).then((shareConfig) => {
          // 缓存分享卡片图片路径
          that.setData({
            shareCardImageUrl: shareConfig.imageUrl
          });
          // 返回分享配置，供调用方使用
          return shareConfig;
        }).catch((err) => {
          console.error('生成分享卡片失败:', err);
          // 失败时使用基础图
          const fallbackConfig = {
            imageUrl: '/static/images/shareBase.png'
          };
          that.setData({
            shareCardImageUrl: fallbackConfig.imageUrl
          });
          return fallbackConfig;
        });
      } else {
        // 如果获取详情数据失败，返回基础图配置
        const fallbackConfig = {
          imageUrl: '/static/images/shareBase.png'
        };
        that.setData({
          shareCardImageUrl: fallbackConfig.imageUrl
        });
        return Promise.resolve(fallbackConfig);
      }
    }).catch((err) => {
      console.error('获取详情数据失败:', err);
      // 返回基础图配置
      const fallbackConfig = {
        imageUrl: '/static/images/shareBase.png'
      };
      that.setData({
        shareCardImageUrl: fallbackConfig.imageUrl
      });
      return Promise.resolve(fallbackConfig);
    });
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage: async function () {
    const { publishedId, shareCardImageUrl } = this.data;
    
    if (!publishedId) {
      return {
        title: "滑雪去小程序",
        path: "/pages/index/index",
        imageUrl: "/static/images/shareBase.png"
      };
    }
    
    // 获取分享配置
    const shareConfig = shareCard.getShareConfig('ticket', {
      id: publishedId,
      type: 0,
      skiResort: {}
    });
    
    // 如果没有缓存的分享卡片，显示loading并同步等待生成完成
    if (!shareCardImageUrl) {
      wx.showLoading({
        title: '生成分享卡片中...',
        mask: true
      });
      try {
        // 同步等待分享卡片生成完成，并获取返回的分享配置
        const generatedConfig = await this.generateShareCard(publishedId);
        // 使用生成的分享卡片图片
        shareConfig.imageUrl = generatedConfig?.imageUrl || '/static/images/shareBase.png';
      } catch (err) {
        console.error('生成分享卡片失败:', err);
        shareConfig.imageUrl = '/static/images/shareBase.png';
      } finally {
        wx.hideLoading();
      }
    } else {
      // 使用缓存的分享卡片图片
      shareConfig.imageUrl = shareCardImageUrl;
    }
    
    return shareConfig;
  },

  /**
   * 处理查看
   */
  handleView: function () {
    const { publishedId } = this.data;

    // 关闭弹窗
    this.setData({
      showSuccessPopup: false
    });

    setTimeout(() => {
      if (publishedId) {
        // 跳转到详情页
        wx.redirectTo({
          url: `/pages/ticketDetail/ticketDetail?id=${publishedId}`,
          fail: (err) => {
            console.error("跳转失败:", err);
            wx.navigateBack();
          }
        });
      } else {
        // 如果没有ID，返回上一页
        wx.navigateBack();
      }
    }, 300);
  },

  /**
   * 加入俱乐部
   */
  joinClub: function () {
    console.log("点击加入俱乐部");

    // 关闭成功弹窗
    this.setData({
      showSuccessPopup: false
    });

    // 使用工具函数进行登录校验
    util.executeWithLoginCheck(
      () => {
        // 用户已登录，跳转到加入俱乐部页面
        wx.navigateTo({
          url: "/pages/clubJoin/clubJoin",
          success: function () {
            console.log("跳转到加入俱乐部页面成功");
          },
          fail: function (err) {
            console.error("跳转到加入俱乐部页面失败:", err);
            wx.showToast({
              title: "页面跳转失败",
              icon: "none",
              duration: 2000
            });
          }
        });
      },
      "加入俱乐部需要先登录，是否立即登录？",
      "/pages/ticketAdd/ticketAdd"
    );
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady: function () {
    console.log("雪票发布页面渲染完成");
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {
    console.log("雪票发布页面显示");
    // 加载用户信息，判断是否已加入俱乐部
    this.loadUserInfo();
    
    // 编辑模式下不恢复缓存，因为编辑模式应该显示从服务器加载的数据
    if (this.data.isEditMode) {
      return
    }
    
    // 检查是否有缓存的表单数据（从登录页面返回时恢复）
    const userInfo = wx.getStorageSync('userInfo')
    const token = wx.getStorageSync('token')
    const navUrl = wx.getStorageSync('navUrl')
    
    // 如果用户已登录，检查并恢复缓存的表单数据
    if (userInfo && token) {
      // 如果 navUrl 匹配，清除导航URL
      if (navUrl === '/pages/ticketAdd/ticketAdd') {
        wx.removeStorageSync('navUrl')
      }
      // 无论 navUrl 是否匹配，都尝试恢复缓存（防止 navUrl 未设置的情况）
      this.restoreFormData()
    }
  },

  /**
   * 加载用户信息
   */
  loadUserInfo: function () {
    // 从本地存储获取用户信息
    const userInfo = wx.getStorageSync("userInfo");
    const token = wx.getStorageSync("token");

    if (userInfo && token) {
      // 判断是否已加入俱乐部
      const isClubMember = userInfo.isClub === 1;

      this.setData({
        isClubMember: isClubMember
      });

      console.log("用户信息加载成功:", userInfo);
      console.log("是否已加入俱乐部:", isClubMember);
    } else {
      this.setData({
        isClubMember: false
      });
    }
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide: function () {
    console.log("雪票发布页面隐藏");
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload: function () {
    console.log("雪票发布页面卸载");
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh: function () {
    console.log("用户下拉刷新");
    // 停止下拉刷新
    wx.stopPullDownRefresh();
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom: function () {
    console.log("页面触底");
  },
});
